home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / System / flow.c < prev    next >
Text File  |  1986-04-19  |  4KB  |  225 lines
  1. /* ----------------- flow ----------------- 
  2.  *
  3.  * Make the Mac screen flow away.
  4.  * Written in Aztec C.
  5.  * 
  6.  * Author:   Fons Rademakers, Nikhef-h/CERN
  7.  * Version:  29-oct-1985
  8.  * Revision:
  9.  *
  10.  */
  11.  
  12. #asm
  13. main
  14.     dc.w  $6400        ;ctl-enable, need time and locked in mem.
  15.     dc.w  0          ;update as often as possible
  16.     dc.w  $0001        ;don't react on any specific event
  17.     dc.w  0            ;no menu
  18.  
  19.     dc.w  open_-main        ;open routine
  20.     dc.w  nop_-main        ;prime routine
  21.     dc.w  control_-main    ;control routine
  22.     dc.w  nop_-main        ;status routine
  23.     dc.w  close_-main     ;close routine
  24.  
  25. title_
  26.     dc.b  4
  27.     dc.b  "Flow"
  28.     ds    0              ;for alignment
  29.  
  30.     public   _Uend_,_Dorg_,_Cend_
  31.  
  32. save_
  33.     lea     main+(_Uend_-_Dorg_)+(_Cend_-main),a4    ;set up globals
  34.     move.l  a0,Pbp_                                    ;save pb pointer
  35.     move.l  a1,Dp_                                        ;save DCE pointer
  36.     rts
  37.  
  38. restore_
  39.     move.l  Pbp_,a0
  40.     rts
  41. #endasm
  42.  
  43. #define     _DRIVER
  44. #define  SMALL_MEM
  45. #include <quickdraw.h>
  46. #include <memory.h>
  47. #undef   SMALL_MEM
  48. #include <event.h>
  49. #include <pb.h>
  50. #include <desk.h>
  51.  
  52. #define NULL  (0L)
  53.  
  54. #define BASE1 512        /* Mac screen size in x direction */
  55. #define BASE2 342        /* Mac screen size in y direction */
  56.  
  57. #define SP (*(struct storage **)Dp->dCtlStorage)
  58.  
  59. DCEPtr  Dp;
  60. ParmBlkPtr  Pbp;
  61.  
  62. Rect wind_rect = {0, 0, 0, 0};
  63.  
  64. struct storage {
  65.     GrafPtr flowport;            /* the flow grafport */
  66.     Pattern black;
  67.     short   portspace[54];       /* space for the flowport */
  68.     short   y;
  69. };
  70.  
  71. open()
  72. {
  73.     register WindowPtr wp;
  74.     register struct DCE *dp;
  75.     register struct storage *sp;
  76.     extern char title[];
  77.     struct windowpeek {
  78.         GrafPort port;
  79.         int      windowKind;
  80.     };
  81.     short    x, i;
  82.  
  83.     save();
  84.     dp = Dp;
  85.     if (dp->dCtlWindow == NULL) {
  86.         HLock(dp->dCtlStorage = NewHandle((long) sizeof(struct storage)));
  87.         sp = SP;
  88.         /* create an invisible window */
  89.         dp->dCtlWindow =         
  90.         wp = NewWindow(NULL, &wind_rect, title, FALSE, plainDBox, -1L, FALSE, 
  91. NULL);
  92.         ((struct windowpeek *)wp)->windowKind = dp->dCtlRefNum;
  93.         /* allocate space for new flowport */
  94.         &sp->flowport->device = sp->portspace;
  95.         OpenPort(sp->flowport);
  96.         /* set start y value */
  97.         sp->y = 0;
  98.         /* black pattern */
  99.         StuffHex(sp->black, "\PFFFFFFFFFFFFFFFF");
  100.         /* set the background pattern to black */
  101.         BackPat(sp->black);
  102.  
  103.         HUnlock(dp->dCtlStorage);
  104.     }
  105.     restore();
  106.     return(0);
  107. }
  108.  
  109.  
  110. close()
  111. {
  112.     register struct DCE *dp;
  113.  
  114.     save();
  115.     dp = Dp;
  116.     /* get rid of the allocated space for the window */
  117.     DisposeWindow(dp->dCtlWindow);
  118.     dp->dCtlWindow = NULL;
  119.     DisposHandle(dp->dCtlStorage);
  120.     restore();
  121.     return(0);
  122. }
  123.  
  124.  
  125. nop()
  126. {
  127.     return(0);
  128. }
  129.  
  130.  
  131.  
  132.  
  133. control()
  134. {
  135.     register struct DCE *dp;
  136.     register struct storage *sp;
  137.     short     x, i;
  138.     short     xdest, ydest;
  139.     Rect      destrect;
  140.     RgnHandle dummyrgn;
  141.  
  142.     save();
  143.     dp = Dp;
  144.     HLock(dp->dCtlStorage);
  145.     sp = SP;
  146.     switch (Pbp->u.cp.csCode) {
  147.     case accRun:        /* time to flow the screen */
  148.         SetPort(sp->flowport);
  149.         if (sp->y <= BASE2) {
  150.             for (i = 1; i <= 7; i++) {
  151.                 dummyrgn = NewRgn();
  152.                 x = jrand(BASE1);
  153.                 SetRect(&destrect, x, sp->y, min(x+150, BASE1), rand(sp->y, BASE2));
  154.                 xdest = rand(-3, 3);
  155.                 ydest = rand(1, 4);
  156.                 ScrollRect(&destrect, xdest, ydest, dummyrgn);
  157.                 DisposeRgn(dummyrgn);
  158.             }
  159.             MoveTo(0, sp->y);
  160.             LineTo(BASE1, sp->y);
  161.             sp->y++;
  162.         } else
  163.             sp->y = 0;
  164.         break;  /* end case */
  165.     }
  166.     HUnlock(dp->dCtlStorage);
  167.     restore();
  168.     return(0);
  169. }
  170.  
  171.  
  172. /* Return random number uniformly distributed on [min,max].
  173.  * Note that Random() delivers a value on [-32768,32767]. */
  174. rand(min, max)
  175. int min, max;
  176. {
  177.     float ran;
  178.  
  179.     ran = (max - min + 1.0)*(float)abs(Random())/32768.0 + min;
  180.     return((ran < 0) ? --ran : ran);
  181. }
  182.  
  183.  
  184. /* Return random number, on base [0, base>, with quadratic emphasis
  185.  * round base/2. */
  186. jrand(base)
  187. int base;
  188. {
  189.     float x, ran;
  190.  
  191.     x = (float)abs(Random())/32768.0;   /* random number uniformly on [0, 
  192. 1> */
  193.     ran = 2.0*(float)base*x*(1.0 - x);
  194.     if (x >= 0.5)
  195.         ran = (float)base - ran;
  196.     return(ran);
  197. }
  198.  
  199.  
  200.  
  201. /* Return absolute value of an integer */
  202. abs(n)
  203. int n;
  204. {
  205.     return((n > 0) ? n : -n);
  206. }
  207.  
  208.  
  209.  
  210. /* Return the max integer */
  211. max(a, b)
  212. int a, b;
  213. {
  214.     return((a > b) ? a : b);
  215. }
  216.  
  217.  
  218. /* Return the min integer */
  219. min(a, b)
  220. int a, b;
  221. {
  222.     return((a < b) ? a : b);
  223. }
  224.  
  225.